// src/api/case/index.js
import http from '@/axios'

// 案件状态枚举
const CASE_STATUS = {
    PENDING: '1',      // 待受理
    PROCESSING: '2',   // 处理中
    COMPLETED: '3',    // 已完成
    CANCELLED: '4'     // 已取消
}

// 案件类型枚举
const CASE_TYPE = {
    CIVIL: '1',        // 民事案件
    CRIMINAL: '2',     // 刑事案件
    ADMINISTRATIVE: '3', // 行政案件
    OTHER: '4'         // 其他案件
}

// 模拟案件数据
const mockCases = Array.from({length: 50}, (_, i) => ({
    id: 1000 + i,
    caseName: `案件 ${i + 1}`,
    status: String(Math.floor(Math.random() * 7) + 1),
    caseType: String(Math.floor(Math.random() * 4) + 1),
    createTime: new Date(Date.now() - Math.floor(Math.random() * 30) * 24 * 60 * 60 * 1000)
        .toISOString().split('T')[0],
    realName: `用户${i}`,
    lawyerName: `律师${i}`,
    description: `这是案件${i + 1}的详细描述，包含案件的基本情况和处理过程。`
}))

export default {
    // 获取案件列表
    getCaseList(params) {
        // 在开发环境直接返回模拟数据
        if (import.meta.env.MODE === 'development') {
            return new Promise(resolve => {
                setTimeout(() => {
                    // 过滤逻辑
                    let filtered = [...mockCases]

                    if (params.caseName) {
                        filtered = filtered.filter(item =>
                            item.caseName.includes(params.caseName)
                        )
                    }

                    if (params.status) {
                        filtered = filtered.filter(item =>
                            item.status === params.status
                        )
                    }

                    if (params.caseType) {
                        filtered = filtered.filter(item =>
                            item.caseType === params.caseType
                        )
                    }

                    if (params.dateRange && params.dateRange.length === 2) {
                        const [start, end] = params.dateRange
                        filtered = filtered.filter(item => {
                            const itemDate = new Date(item.createTime)
                            const startDate = new Date(start)
                            const endDate = new Date(end)
                            return itemDate >= startDate && itemDate <= endDate
                        })
                    }

                    // 分页处理
                    const page = Number(params.page) || 1
                    const size = Number(params.size) || 10
                    const total = filtered.length
                    const startIndex = (page - 1) * size
                    const endIndex = startIndex + size
                    const data = filtered.slice(startIndex, endIndex)

                    resolve({
                        code: 200,
                        data: {
                            list: data,
                            pagination: { page, size, total }
                        }
                    })
                }, 300)
            })
        }

        // 生产环境使用真实API
        return http.get('/api/cases', { params })
    },

    // 获取案件详情
    getCaseDetail(id) {
        // 开发环境使用模拟数据
        if (import.meta.env.MODE === 'development') {
            return new Promise(resolve => {
                setTimeout(() => {
                    const caseData = mockCases.find(item => item.id == id)
                    if (caseData) {
                        resolve({
                            code: 200,
                            data: caseData
                        })
                    } else {
                        resolve({
                            code: 404,
                            message: '案件不存在'
                        })
                    }
                }, 300)
            })
        }

        // 生产环境使用真实API
        return http.get(`/api/cases/${id}`)
    },

    // 创建案件
    createCase(data) {
        // 开发环境使用模拟数据
        if (import.meta.env.MODE === 'development') {
            return new Promise(resolve => {
                setTimeout(() => {
                    const newCase = {
                        id: Math.max(...mockCases.map(c => c.id)) + 1,
                        caseName: data.caseName || '新案件',
                        caseType: data.caseType || '1',
                        status: '1', // 默认待受理状态
                        createTime: new Date().toISOString().split('T')[0],
                        realName: '当前用户',
                        lawyerName: data.lawyerName || '',
                        description: data.description || ''
                    }
                    mockCases.unshift(newCase)
                    resolve({
                        code: 200,
                        data: newCase,
                        message: '创建成功'
                    })
                }, 300)
            })
        }

        // 生产环境使用真实API
        return http.post('/api/cases', data)
    },

    // 更新案件
    updateCase(id, data) {
        // 开发环境使用模拟数据
        if (import.meta.env.MODE === 'development') {
            return new Promise(resolve => {
                setTimeout(() => {
                    const index = mockCases.findIndex(item => item.id == id)
                    if (index !== -1) {
                        mockCases[index] = {
                            ...mockCases[index],
                            ...data
                        }
                        resolve({
                            code: 200,
                            data: mockCases[index],
                            message: '更新成功'
                        })
                    } else {
                        resolve({
                            code: 404,
                            message: '案件不存在'
                        })
                    }
                }, 300)
            })
        }

        // 生产环境使用真实API
        return http.put(`/api/cases/${id}`, data)
    },

    // 删除案件
    deleteCase(id) {
        // 开发环境使用模拟数据
        if (import.meta.env.MODE === 'development') {
            return new Promise(resolve => {
                setTimeout(() => {
                    const index = mockCases.findIndex(item => item.id == id)
                    if (index !== -1) {
                        mockCases.splice(index, 1)
                        resolve({
                            code: 200,
                            message: '删除成功'
                        })
                    } else {
                        resolve({
                            code: 404,
                            message: '案件不存在'
                        })
                    }
                }, 300)
            })
        }

        // 生产环境使用真实API
        return http.delete(`/api/cases/${id}`)
    },

    // 分配律师
    assignLawyer(caseId, lawyerId) {
        return http.post(`/api/cases/${caseId}/assign`, { lawyerId })
    },

    // 导出枚举
    CASE_STATUS,
    CASE_TYPE
}